package com.kt.learn1

/**
 * Kotlin 集合与泛型示例
 * 包括集合的基本操作、泛型类、泛型函数、泛型接口等
 */

fun main() {
    // 集合的基本操作
    chapter1CollectionBasics()

    // 泛型类
    chapter2GenericClass()

    // 泛型函数
    chapter3GenericFunctions()

    // 泛型接口
    chapter4GenericInterfaces()

    // 泛型的变异性
    chapter5Variance()
}

// 集合的基本操作
fun chapter1CollectionBasics() {
    println("\n===== 集合的基本操作 =====")

    // 列表
    val numbers = listOf(1, 2, 3, 4, 5)
    println("Numbers: ${numbers.joinToString()}") // 输出：Numbers: 1, 2, 3, 4, 5

    // 可变列表
    val mutableNumbers = mutableListOf(1, 2, 3)
    mutableNumbers.add(4)
    mutableNumbers.add(5)
    println("Mutable Numbers: ${mutableNumbers.joinToString()}") // 输出：Mutable Numbers: 1, 2, 3, 4, 5

    // 集合
    val colors = setOf("Red", "Green", "Blue")
    println("Colors: ${colors.joinToString()}") // 输出：Colors: Red, Green, Blue

    // 可变集合
    val mutableColors = mutableSetOf("Red", "Green")
    mutableColors.add("Blue")
    println("Mutable Colors: ${mutableColors.joinToString()}") // 输出：Mutable Colors: Red, Green, Blue

    // 映射
    val user = mapOf("name" to "Alice", "age" to 25)
    println("User: ${user.entries.joinToString { "${it.key}=${it.value}" }}") // 输出：User: name=Alice, age=25

    // 可变映射
    val mutableUser = mutableMapOf("name" to "Alice")
    mutableUser["age"] = 25.toString()
    println("Mutable User: ${mutableUser.entries.joinToString { "${it.key}=${it.value}" }}") // 输出：Mutable User: name=Alice, age=25
}

// 定义一个泛型类
class Box<T>(val content: T) {
    @JvmName("getBoxContent")
    fun getContent(): T {
        return content
    }
}

// 泛型类
fun chapter2GenericClass() {
    println("\n===== 泛型类 =====")



    // 创建不同类型的 Box 实例
    val intBox = Box(10)
    val stringBox = Box("Hello")
    println("Int Box Content: ${intBox.getContent()}") // 输出：Int Box Content: 10
    println("String Box Content: ${stringBox.getContent()}") // 输出：String Box Content: Hello
}

// 泛型函数
fun chapter3GenericFunctions() {
    println("\n===== 泛型函数 =====")

    // 定义一个泛型函数
    fun <T> printList(items: List<T>) {
        for (item in items) {
            println(item)
        }
    }

    // 使用泛型函数
    val intList = listOf(1, 2, 3)
    val stringList = listOf("a", "b", "c")
    printList(intList) // 输出：1, 2, 3
    printList(stringList) // 输出：a, b, c
}


// 定义一个泛型接口
interface Printable<T> {
    fun print(item: T)
}

// 泛型接口
fun chapter4GenericInterfaces() {
    println("\n===== 泛型接口 =====")


    // 实现泛型接口
    class StringPrinter : Printable<String> {
        override fun print(item: String) {
            println("Printing string: $item")
        }
    }

    val printer = StringPrinter()
    printer.print("Hello, Kotlin!") // 输出：Printing string: Hello, Kotlin!
}

// 定义一个生产者接口（协变）
interface Producer<out T> {
    fun produce(): T
}

// 定义一个消费者接口（逆变）
interface Consumer<in T> {
    fun consume(item: T)
}

// 泛型的变异性
fun chapter5Variance() {
    println("\n===== 泛型的变异性 =====")



    // 实现生产者接口
    class NumberProducer : Producer<Int> {
        override fun produce(): Int {
            return 42
        }
    }

    // 实现消费者接口
    class NumberConsumer : Consumer<Int> {
        override fun consume(item: Int) {
            println("Consuming number: $item")
        }
    }

    val producer: Producer<Int> = NumberProducer()
    println("Produced number: ${producer.produce()}") // 输出：Produced number: 42

    val consumer: Consumer<Int> = NumberConsumer()
    consumer.consume(42) // 输出：Consuming number: 42
}